package algorithms;

/**
 * 
 * @author Emanuel Martins 5940, Ana Pontes 5950 || date 05/06/2014
 * 
 *         This is the class AStar, this class opens and closes a given queue
 * 
 */

public class AStar
{

   public AStar(int start, int end)
   {
      FilaEspera closeSet = new FilaEspera(0);
      FilaEspera openSet = new FilaEspera(0);
      FilaEspera came_from = new FilaEspera(0);

      int[] g_score = new int[10];
      // f_score[start] = g_score[start] + this.heuristic_cost_estimate(start,
      // end);

      while (openSet.head == openSet.tail)
      {

      }
   }

   /**
    * This method returns the cost of the heuristic operation
    * 
    * @return the cost of the operation
    */

   private int heuristic_cost_estimate(int start, int goal)
   {
      return 10;
   }

}
/**
 * 
 * function A*(start,goal) closedset := the empty set // The set of nodes
 * already evaluated. openset := {start} // The set of tentative nodes to be
 * evaluated, initially containing the start node came_from := the empty map //
 * The map of navigated nodes.
 * 
 * g_score[start] := 0 // Cost from start along best known path. // Estimated
 * total cost from start to goal through y. f_score[start] := g_score[start] +
 * heuristic_cost_estimate(start, goal)
 * 
 * while openset is not empty current := the node in openset having the lowest
 * f_score[] value if current = goal return reconstruct_path(came_from, goal)
 * 
 * remove current from openset add current to closedset for each neighbor in
 * neighbor_nodes(current) if neighbor in closedset continue tentative_g_score
 * := g_score[current] + dist_between(current,neighbor)
 * 
 * if neighbor not in openset or tentative_g_score < g_score[neighbor]
 * came_from[neighbor] := current g_score[neighbor] := tentative_g_score
 * f_score[neighbor] := g_score[neighbor] + heuristic_cost_estimate(neighbor,
 * goal) if neighbor not in openset add neighbor to openset
 * 
 * return failure
 * 
 * function reconstruct_path(came_from, current_node) if current_node in
 * came_from p := reconstruct_path(came_from, came_from[current_node]) return (p
 * + current_node) else return current_node
 */
